<?
/**
 * Map - Classe de génération de la carte galaxy
 * Ainsi que ces entités
 *
 * @author Staff Centaurius
 * @date 11 Avril 2008
 **/
class Map {

	public $galaxy_name;
	public $gen_console;
	public $systemes_nb;
	private $image_forme;
	private $image_zones;
	private $image_map;
	private $image_colors;
	private $systemes_tbl;
	private $sys_type_tbl;
	private $sys_names;

	/**
	* Constructeur d'objet
	**/
	public function __construct() {

		// Empeche l'arrêt du script
		set_time_limit(0);
		//Augmente la limite de memoire de php
		ini_set("memory_limit","100M"); //a optimiser :S

		//Initialisation de la carte
		$this->galaxy_name = _GALAX_NAME;
		$this->gen_console = "";
		$this->image_map = NULL;
		$this->image_zones = NULL;
		$this->image_form = NULL;
		$this->systemes_tbl = array();
		$this->image_colors = array();
		$this->systemes_nb = 0;
		$this->sys_type_tbl = array();
		$this->sys_names = array();
		$this->loadSysNames(); //charge les noms de systeme

		$this->addMapConsol("Initialisation objet map ........OK");
	}

	/**
	* Destructeur de l'objet map
	**/
	public function __destruct() {

		//restoration de la limite de memmoire
		ini_restore ("memory_limit");

		//Destruction  de l'objet
		return true;
	}

	/**
	* Ajout ligne dans sortie console
	*
	* @param string $line
	**/
	private function addMapConsol($line = "") {

		$line_update = "<br />" . $line;
		$this->gen_console .= $line_update;

		Log::logShell($line, 4);
	}

	/**
	* Calcule une probabilité et retourne le résultat (oui, non)
	*
	* @param string $probab_val (0 aucune chance, 100 toutes les chances)
	* @return bool
	**/
	private function getLuck($probab_val) {

		$rand_val = mt_rand(1, 100);

		if ($probab_val > $rand_val) {
			return true;
		} else {
			return false;
		}
	}

	/**
	* Charge les noms de systemes solaires
	*
	* @return bool
	**/
	private function loadSysNames() {

		$sys_names = array();

		//Recuperation table des noms des systemes solaires
		$res = SQLManager::query("SELECT sname_nom FROM s_sysname ORDER BY sname_nom ASC");

		if (SQLManager::num_rows($res) <= 0) {

			$this->addMapConsol("Aucun nom de systemes chargés !", 4);
			return false;
		}

		//Chargement des noms systemes solaires
		$this->sys_names = SQLManager::fetch_all($res);
	}

	/**
	* Génération des systemes solaires
	**/
	public function genSystemes() {

		$sys_nb_gen = 0;
		$sys_nom = "";
		$sys_x = 0;
		$sys_y = 0;
		$sys_ok = false;
		$Data = new DataManager(Registry::get('conf')->db_name);

		//Initialisation galaxie
		if ($Data->initGalax() == TRUE AND $Data->initAstres() == TRUE) {
			$this->addMapConsol("Initialisation galaxie");
		}

		//Génération nombre systemes
		$this->systemes_nb = mt_rand(_MAX_SYSTEM, _MAX_SYSTEM + 20);
		$this->addMapConsol("Nombre de systemes solaires : " . $this->systemes_nb);

		//Création des systemes
		do {

			//Initialisation valeurs
			$sys_nom = "";
			$sys_x = 0;
			$sys_y = 0;
			$sys_ok = false;

			//Tant que les valeurs ne sont pas valides
			do {
				//Génération valeurs
				$this->genSystemeInfo($sys_nom, $sys_x, $sys_y);

				$this->addMapConsol("Génération systeme : " . $sys_x . " : " . $sys_y);

				//valeurs valides ?
				$sys_ok = $this->getLuck($this->getSystemePosProbab($sys_nom, $sys_x, $sys_y));

				//on remet le nom dans la liste des nom si le sys n'est pas valide
				if ($sys_ok == false) $this->sys_names[] = $sys_nom;

				$this->addMapConsol("Validité : " . $sys_ok);

			} while($sys_ok == false);

			//Chargement systement solaire
			$this->systemes_tbl[] = array('nom' => $sys_nom, 'x' => $sys_x, 'y' => $sys_y);

			$sys_nb_gen++;

		} while($sys_nb_gen < $this->systemes_nb);

		$this->addMapConsol("Génération systemes solaires........ OK");
		//$this->addMapConsol(Log::print_r_html($this->systemes_tbl));

		//Génération du fichier JS galaxie
		$this->genGalaxJSFile();

		$this->addMapConsol("Enregistrement systemes solaires....... OK");

		foreach($this->systemes_tbl as &$sys) {

			//Création enregistrment DB systeme
			SQLManager::query("INSERT INTO d_systeme VALUES('', $sys[x], $sys[y], '$sys[nom]', 0)");
		}

		$this->addMapConsol("Création systemes solaires......... Ok");

		return true;
	}

	/**
	* Génére les valeurs du systeme solaire
	* (variables de retour passées par adresse !)
	*
	* @param int $sys_x
	* @param int $sys_y
	* @return int (niveau de probabilité de 0 a 100)
	**/
	private function genSystemeInfo(&$sys_nom, &$sys_x, &$sys_y) {

		//Génération du nom
		$sys_nom = $this->getSysName();

		//Génération de la position
		$sys_x = mt_rand(2, _GALAX_SIZE_X_COEF - 1);
		$sys_y = mt_rand(2, _GALAX_SIZE_Y_COEF - 1);
	}

	/**
	* Retourne un nom de systeme
	*
	* @return string (nom du systeme)
	**/
	private function getSysName() {

		$name 		= "";
		$sys_offset = array_rand($this->sys_names);

		if (isset($this->sys_names[$sys_offset])) {

			$name = $this->sys_names[$sys_offset]['sname_nom'];
			unset($this->sys_names[$sys_offset]);
		}

		return $name;
	}

	/**
	* Donne la probabilité du secteur d'etre a cette position
	*
	* @param int $sys_x
	* @param int $sys_y
	* @return int (niveau de probabilité de 0 a 100)
	**/
	private function getSystemePosProbab($sys_nom, $sys_x, $sys_y) {

		$sys_propab = 50;

		foreach($this->systemes_tbl as &$sys) {
			//Si un systeme existe déja a cette adresse
			if ($sys_x == $sys['x'] AND $sys_y == $sys['y']) {
				//aucune chance
				$sys_propab = 0;
				break;
			}
		}

		if ($sys_propab > 0) {
			//Calcule de la probabilité en fonction du masque de forme
			$sys_propab = $this->getSysProbabMask($sys_x, $sys_y);
		}

		return $sys_propab;
	}

	/**
	* Charge la liste des systemes solaires existants
	*
	* @return void
	**/
	public function loadSystemes() {

		$sys_owner = 0;
		$sys_fact  = array();

		//Recuperation table systeme
		$res_sys = SQLManager::query("SELECT s.sys_id, s.sys_pos_x as x, s.sys_pos_y as y,
										s.sys_nom as nom, '#FFFFFF' as color
									FROM d_systeme s
									ORDER BY s.sys_id ASC");
		$systemes = SQLManager::fetch_all($res_sys, 'sys_id');

		if (count($systemes) > 0) {
			//Si il y a des systemes trouvés
			$this->systemes_tbl = $systemes;
			$this->systemes_nb = count($systemes);

			//Traitement sur les systemes chargés
			foreach($this->systemes_tbl as &$sys) {

				//Traitement sur le systeme pour définir la faction qui le domine
				$sys_fact  = array();
				$sys_owner = Faction::getSystemeOwnerFaction($sys['x'], $sys['y']);
				//Si il y a une faction dominante dans ce systeme
				if ($sys_owner != FALSE) {
					//récupération des informations du systeme
					$sys_fact = Faction::getFactionList($sys_owner);
					//Si il y a une couleur pour la faction
					if (isset($sys_fact[0]['fact_color']) AND $sys_fact[0]['fact_color'] != '') {
						//Coloration du systeme
						$sys['color'] = $sys_fact[0]['fact_color'];
					}
				}
			}
			$this->addMapConsol("Nombre de systemes solaires chargés : " . $this->systemes_nb);
		}

		$systemes = NULL;
		return true;
	}

	/**
	* Vide et Génere le fichier Javascript des systemes
	*
	* @return bool
	**/
	public function genGalaxJSFile() {

		$js_file 	= _GAMEBASE . 'ressource/script/map/systemes.js';
		$hand_file 	= NULL;
		$empty_file = false;
		$sys_line 	= "";

		if (count($this->systemes_tbl) > 0) {

			//Suppression de l'ancien fichier
			$empty_file = unlink($js_file);

			if ($empty_file == false) {
				$this->addMapConsol("Erreur de droit sur le fichier JS galaxie");
				return false;
			}

			//Création et ouverture du nouveau fichier
			$hand_file = fopen($js_file, "w+");

			//Protection contre les cartes vides
			if (count($this->systemes_tbl) > 0) {

				$this->addMapConsol("Génération fichier JS galaxie");

				//Pour chaque systemes
				foreach($this->systemes_tbl as &$systeme) {

					$sys_line = "\nSysArray['$systeme[x]:$systeme[y]'] = new Array('$systeme[nom]', '$systeme[color]');";

					//ecriture de la ligne du systeme dans le nouveau fichier
					fwrite($hand_file, $sys_line);
				}
			}

			//Fermeture du fichier
			fclose($hand_file);

		} else {

			$this->addMapConsol("Erreur : aucun systeme chargé");
			$this->addMapConsol("Génération JS galaxie......... ERREUR");

			return false;
		}

		return true;
	}

	/**
	* Generation de l'image de la galaxie
	*
	* @return bool (génération réussi ou pas)
	**/
	public function genGalaxImage() {

		$pos_x = 0;
		$pos_y = 0;
		$sys_color_id = 0;
		$sys_color = NULL;
		$backup_name = "map_" . date('dmY') . ".jpg";

		//Protection contre les cartes vides
		if (count($this->systemes_tbl) > 0) {

			if (BACKUP_MAP_ACTIVE == true) {
				//Backup map avant génération si activé
				copy(_GAMEBASE . 'ressource/image/map/map1.jpg',
					_GAMEBASE . 'ressource/image/map/backup/' . $backup_name);
			}

			$this->addMapConsol("Génération image galaxie");

			//Chargement de l'image de fond et création de l'image
			$this->image_map = imagecreatefromjpeg(_GAMEBASE . 'ressource/image/map/ress/map_blank.jpg');

			//Couleur des systeme par défaut
			$this->image_colors['sys_default'] = imagecolorallocate($this->image_map, 220, 200, 210);

			//Pour chaque systemes
			foreach($this->systemes_tbl as &$systeme) {

				$sys_color_id = 0;
				$sys_color = NULL;

				//Recherche si le secteur est sous domination
				if (isset($systeme['color']) AND $systeme['color'] != '#FFFFFF') {

					$sys_color_id = base_convert(substr($systeme['color'], 1), 16, 10);
					//Si la couleur n'est pas chargée
					if (!isset($this->image_colors[$sys_color_id])) {
						//Chargement de la couleur
						$this->image_colors[$sys_color_id] = imagecolorallocate($this->image_map,
																				($sys_color_id >> 16) & 0xFF,
																				($sys_color_id >> 8) & 0xFF,
																				$sys_color_id & 0xFF);
					}
					//Couleur de la faction
					$sys_color = $this->image_colors[$sys_color_id];

				} else {
					//Si pas sou domination, couleur par defaut
					$sys_color = $this->image_colors['sys_default'];
				}

				//calcule de la position du systeme sur l'image
				$pos_x = ($systeme['x'] * 15) - 7;
				$pos_y = ($systeme['y'] * 15) - 7;

				//Dessin du systeme sur l'image
				imagefilledellipse($this->image_map, $pos_x, $pos_y, 12, 12, $sys_color);
			}

			//Enregistrement et destruction de la ressource
			imagejpeg($this->image_map, _GAMEBASE . 'ressource/image/map/map1.jpg');
			imagedestroy($this->image_map);

			$this->addMapConsol("Génération image galaxie......... OK");

			return true;

		} else {

			$this->addMapConsol("Erreur : aucun systeme chargé");
			$this->addMapConsol("Génération image galaxie......... ERREUR");

			return false;
		}
	}

	/**
	* Récupération de la probabilité de position
	* a partir d'une image a 4 niveau de couleurs
	*
	* @return int (probabilité de chance (95 - 5 sur 100)
	**/
	public function getSysProbabMask($sys_x, $sys_y) {

		$probab_value = 0;
		$color_id = NULL;
		//Calcule de la position en pixel
		$pos_x = ($sys_x * 15) - 6;
		$pos_y = ($sys_y * 15) - 6;

		if ($this->image_forme == NULL) {
			//Chargement de l'image de masque de forme
			$this->image_forme = imagecreatefromjpeg(_GAMEBASE . 'ressource/image/map/ress/map_forme_mask.jpg');
		}

		//Récupération de la couleur a la position
		$color_id = imagecolorat($this->image_forme, $pos_x, $pos_y);

		//Selon la couleur
		switch($color_id) {

			case 2874629:
				$probab_value = 95;
				break;

			case 16711174:
				$probab_value = 40;
				break;

			case 16621826:
				$probab_value = 15;
				break;

			case 11213319:
				$probab_value = 5;
				break;
		}

		return $probab_value;
	}

	/**
	* Génere un type de secteur
	* en tenant compte de ceux existant
	*
	* @return int (probabilité de chance (95 - 5 sur 100)
	**/
	private function genSysType() {

		$sys_type = 1;
		$max_type = 3;

		if (!isset($this->sys_type_tbl[3]) OR $this->sys_type_tbl[3] == 0) {
			//Création du quasar
			$this->sys_type_tbl[3] = 1;
			return 3;
		}

		if (!isset($this->sys_type_tbl[2]) OR $this->sys_type_tbl[2] < 15) {
			//création des nova
			if (!isset($this->sys_type_tbl[2])) {
				$this->sys_type_tbl[2] = 1;
			} else {
				$this->sys_type_tbl[2]++;
			}
			return 2;
		}

		return 1;
	}

	/**
	* Génération des astres des systemes chargés
	**/
	public function genAstres() {

		$sys_type = 0;
		$sys_neutral = 0;
		$astre_id = 0;
		$astre_id_parent = 0;
		$sys_nb_planetes = 0;
		$sys_nb_moon = 0;
		$sys_nb_astero = 0;
		$planetes_nb_gen = 0;
		$moon_nb_gen = 0;
		$astero_nb_gen = 0;
		$astre_nom = "";
		$astre_x = 0;  $astre_y = 0;
		$light_x = 0;  $light_y = 0;
		$astre_type = 1;  $astre_taille = 0;
		$astre_image = 0;  $astre_condition = 0;
		$astre_ok = false;
		$Data = new DataManager(Registry::get('conf')->db_name);

		//Initialisation astres
		if ($Data->initAstres() == TRUE) {
			$this->addMapConsol("Initialisation des astres");
		}

		//Pour chaque secteurs
		foreach($this->systemes_tbl as &$systeme) {

			$this->addMapConsol("Générations astres systeme : " . $systeme['x'] . " : " . $systeme['x']);

			//initialise le conteneur d'astre du sys
			$systeme['astres'] = array();
			$sys_type = 0;
			$planetes_nb_gen = 0;
			$moon_nb_gen = 0;
			$astero_nb_gen = 0;
			$light_x = 0;  $light_y = 0;

			//Définition du type de systeme
			$sys_type = $this->genSysType();
			$this->addMapConsol("Type de systeme : " . $sys_type);

			switch($sys_type) {

				//Systeme a Nova
				case 2:
					//génération nova
					$this->genAstreInfo($astre_nom, $light_x, $light_y, $astre_taille, 7);

					//Chargement soleil
					$systeme['astres'][] = $this->loadAstreValues($astre_nom, $light_x, $light_y, $astre_taille, 7);

					//Intialisation des valeurs astre
					$sys_nb_planetes = mt_rand(_MAX_ASTRES - 5, _MAX_ASTRES + 1);
					$sys_nb_astero = mt_rand(3, 7);
					if ($sys_nb_planetes < _MAX_ASTRES - 1 AND mt_rand(1, 2) == 1) {
						$sys_nb_moon = mt_rand(1, 2);
					}
					break;

				//Systeme a quasar
				case 3:
					//génération quasar
					$this->genAstreInfo($astre_nom, $light_x, $light_y, $astre_taille, 6);

					//Chargement soleil
					$systeme['astres'][] = $this->loadAstreValues($astre_nom, $light_x, $light_y, $astre_taille, 6);

					//Intialisation des valeurs astre
					$sys_nb_planetes = mt_rand(_MAX_ASTRES - 6, _MAX_ASTRES);
					$sys_nb_astero = mt_rand(4, 8);
					$sys_nb_moon = 0;
					break;

				//Systeme clasqiue
				default:
					//génération soleil
					$this->genAstreInfo($astre_nom, $light_x, $light_y, $astre_taille, 3);

					//Chargement soleil
					$systeme['astres'][] = $this->loadAstreValues($astre_nom, $light_x, $light_y, $astre_taille, 3);

					//Intialisation des valeurs astre
					$sys_nb_planetes = mt_rand(_MAX_ASTRES - 4, _MAX_ASTRES + 4);
					$sys_nb_moon = mt_rand(1, $sys_nb_planetes - 3);
					if ($sys_nb_planetes < 10 AND mt_rand(1, 3) == 1) {
						$sys_nb_astero = mt_rand(3, 7);
					}
					break;
			}

			//Génération des planetes
			do {

				$this->addMapConsol("Génération planete : " . $planetes_nb_gen);

				//Initialisation valeurs
				$astre_nom = "";
				$astre_x = 0;  $astre_y = 0;
				$astre_type = 1;  $astre_taille = 0;
				$astre_image = 35;  $astre_condition = 0;
				$astre_ok = false;

				//Tant que les valeurs ne sont pas valides
				do {
					//Génération valeurs
					$this->genAstreInfo($astre_nom, $astre_x, $astre_y, $astre_taille, 1);

					$this->addMapConsol("Coordonées : " . $astre_x . " : " . $astre_y . " (taille : " . $astre_taille . ")");

					//valeurs valides ?
					$astre_ok = $this->getLuck($this->getAstrePosProbab($systeme, $astre_nom, $astre_x, $astre_y, 1));

					$this->addMapConsol("Vailidité planete : " . $astre_ok);

				} while($astre_ok == false);

				//Chargement astre
				$systeme['astres'][] = $this->loadAstreValues($astre_nom, $astre_x, $astre_y, $astre_taille,
																			1, $light_x, $light_y);
				$planetes_nb_gen++;

			} while($planetes_nb_gen < $sys_nb_planetes);

			$this->addMapConsol("Génération planetes systeme......... Ok");

			//Si il y a des lunes
			if ($sys_nb_moon > 0) {

				//Génération des lunes
				do {

					//Initialisation valeurs
					$astre_nom = "";
					$astre_x = 0;  $astre_y = 0;
					$astre_type = 1;  $astre_taille = 0;
					$astre_image = 35;  $astre_condition = 0;
					$astre_ok = false;

					//Tant que les valeurs ne sont pas valides
					do {

						//Récupération d'un astre parent
						$astre_id_parent = array_rand($systeme['astres']);

						if ($astre_id_parent <= 0) {
							//Si aucun astre parent trouvé
							break(2);
						} else {
							if ($systeme['astres'][$astre_id_parent]['type'] != 1) {
								//Si astre parent pas une planete
								break(2);
							}
							$astre_x = $systeme['astres'][$astre_id_parent]['x'];
							$astre_y = $systeme['astres'][$astre_id_parent]['y'];
						}

						$this->addMapConsol("Coordonées parent de lune : " . $astre_x . " : " . $astre_y);

						//Génération valeurs
						$this->genAstreInfo($astre_nom, $astre_x, $astre_y, $astre_taille, 2);

						$this->addMapConsol("Coordonées de lune : " . $astre_x . " : " . $astre_y);

						//valeurs valides ?
						$astre_ok = $this->getLuck($this->getAstrePosProbab($systeme, $astre_nom, $astre_x, $astre_y, 2));

						$this->addMapConsol("Vailidité lune : " . $astre_ok);

					} while($astre_ok == false);

					//Chargement astre
					$systeme['astres'][] = $this->loadAstreValues($astre_nom, $astre_x, $astre_y, $astre_taille, 2);

					$moon_nb_gen++;

				} while($moon_nb_gen < $sys_nb_moon);
			}

			$this->addMapConsol("Génération Lunes systeme......... Ok");

			//Si il y a des astéroides
			if ($sys_nb_astero > 0) {

				//position de début de la chaine
				$astre_x = mt_rand(3, 8);
				$astre_y = mt_rand(2, 12);

				$this->addMapConsol("Coorodnées asteroides parent : " . $astre_x . " : " . $astre_y);

				//Génération des astéroides
				do {

					//Initialisation valeurs
					$astre_nom = "";
					$astre_taille = 0;
					$astre_image = 35;
					$astre_condition = 0;
					$astre_ok = false;

					//Tant que les valeurs ne sont pas valides
					do {

						//Génération valeurs
						$this->genAstreInfo($astre_nom, $astre_x, $astre_y, $astre_taille, 4);

						if ($astre_x == 0 AND $astre_y == 0) {
							//erruer de génération
							break(2);
						}

						$this->addMapConsol("Coorodnées asteroides : " . $astre_x . " : " . $astre_y);

						//valeurs valides ?
						$astre_ok = $this->getLuck($this->getAstrePosProbab($systeme, $astre_nom, $astre_x, $astre_y, 4));

						$this->addMapConsol("Validité asteroide : " . $astre_ok);

						//sleep(1);
						$astero_nb_gen++;

					} while($astre_ok == false);

					//Chargement astre
					$systeme['astres'][] = $this->loadAstreValues($astre_nom, $astre_x, $astre_y, $astre_taille, 4);


				} while($astero_nb_gen < $sys_nb_astero);
			}

			$this->addMapConsol("Génération Asteroides systeme......... Ok");

		}

		$this->addMapConsol("Enregistrement des astres");

		//Enregistrement des astres de chaque systemes
		foreach($this->systemes_tbl as &$sys) {

			//Si le systeme a des astres
			if (count($sys['astres']) > 0) {

				if ($astre['type'] == 1) {
					//Systeme neutre ?
					$sys_neutral = $this->getSysNeutral($sys['x'], $sys['y']);
				}

				//Pour chaque astres
				foreach($sys['astres'] as &$astre) {

					$astre_id = 0;

					/************************
					 * Modif effectuées pour la Alpha
					 * (si astre en zone neutre : conditions a minimum 4
					 */

					if ($sys_neutral == 1 AND $astre['type'] == 1 AND $astre['conditions'] < 4) {
						$astre['conditions'] = 4;
					}

					 /***********************/

					//Création enregistrment DB astre
					SQLManager::query("INSERT INTO d_astre
										VALUES('', '$astre[nom]', $sys[x], $sys[y], $astre[x], $astre[y], $astre[type],
										 $astre[size], $astre[size], $astre[image], $astre[conditions], $sys_neutral, 0)");
					$astre_id = SQLManager::last_insert_id();

					//Si astre crée
					if ($astre_id > 0) {

						//Création des enregistrements de ressources
						for($i = 1; $i <= _WOLRD_NB_RESS; $i++) {
							//Création ressources
							SQLManager::query("INSERT INTO d_ressource_astre VALUES($i, $astre_id, 0, 0, 0)");
							//Création coef de ressources
							if ($i <= 3) {
								//Juste pour les ressources primaires
								SQLManager::query("INSERT INTO d_ressource_astre_coef VALUES($astre_id, $i, " . _ASTRE_NB_SLOT_RESS . ")");
							}

						}
					}
				}
			}
		}

		$this->addMapConsol("Création astres......... Ok");

		return true;
	}

	/**
	 * Charge un astre
	 *
	 * @return void
	 **/
	private function loadAstreValues($astre_nom, $astre_x, $astre_y, $astre_taille,
										$astre_type = 1, $light_x = 0, $light_y = 0) {

		$astre_tbl = array();
		$light_distance = 0;
		$astre_taille_up = 1;

		$astre_tbl['nom'] = $astre_nom;
		$astre_tbl['x'] = $astre_x;
		$astre_tbl['y'] = $astre_y;
		$astre_tbl['size'] = $astre_taille;
		$astre_tbl['type'] = $astre_type;

		switch($astre_type) {

			//Planete
			case 1:
				//Génération des conditions de vie
				if ($light_x != 0 AND $light_y != 0) {
					//Calcule de la distance de l'astre de son point de lumiere
					//Arrondi a l'entier inferieur
					$light_distance = floor(sqrt(pow(2, abs($astre_x - $light_x)) + pow(2, abs($astre_y - $light_y))));

					if ($light_distance <= 3) {
						//proche du soleil
						$astre_tbl['conditions'] = 1;
					} elseif ($light_distance > 3 AND $light_distance <= 8) {
						//A distance moyenne
						$astre_tbl['conditions'] = mt_rand(3, 5);
					} else {
						//eloigné du soleil
						$astre_tbl['conditions'] = 2;
					}
				} else {
					//Si il n'y a pas de source de lumiere
					$astre_tbl['conditions'] = 2;
				}
				//Génération image planete
				$astre_taille_up = ceil(($astre_taille - (_MAX_PLANETE_SIZE - 40)) / 20);
				if ($astre_taille_up < 1) {
					$astre_taille_up = 1;
				}
				$astre_tbl['image'] = ($astre_taille_up * 10) + $astre_tbl['conditions'];
				break;

			//Lune
			case 2:
				$astre_tbl['conditions'] = 2;
				$astre_tbl['image'] = 10;
				break;

			//Soleil
			case 3:
				$astre_tbl['conditions'] = 0;
				$astre_tbl['image'] = 100;
				break;

			//Asteroide
			case 4:
				$astre_tbl['conditions'] = 1;
				$astre_tbl['image'] = 1000;
				break;

			//Station
			case 5:
				$astre_tbl['conditions'] = 1;
				$astre_tbl['image'] = 10000;
				break;

			//Quasar
			case 6:
				$astre_tbl['conditions'] = 0;
				$astre_tbl['image'] = 50000;
				break;

			//Super nova
			case 7:
				$astre_tbl['conditions'] = 0;
				$astre_tbl['image'] = 51000;
				break;

			default:
				//Valeur d'erreur
				$astre_tbl['conditions'] = 0;
				$astre_tbl['image'] = 0;
				break;
		}

		return $astre_tbl;
	}

	/**
	 * Génere les infos d'un astre
	 * (!! variables passées par adresses !!)
	 *
	 * @return void
	 **/
	private function genAstreInfo(&$astre_nom, &$astre_x, &$astre_y, &$astre_taille, $astre_type = 1) {

		//Génération du nom
		$astre_nom = "Un Astre";

		//Selon le tyle d'astre
		switch($astre_type) {

			//Planetes
			case 1:
				//Génération de la position
				$astre_x = mt_rand(2, _SECT_SIZE_X - 1);
				$astre_y = mt_rand(2, _SECT_SIZE_Y - 1);
				//Génération de la taille
				$astre_taille = mt_rand(_MAX_PLANETE_SIZE - 40, _MAX_PLANETE_SIZE + 40);
				break;

			//Lune
			case 2:
				//si positions planete passées
				if (($astre_x >= 1 AND $astre_x <= _SECT_SIZE_X) AND
					($astre_y >= 1 AND $astre_x < _SECT_SIZE_X))
				{
					//Coté horizontal
					if (mt_rand(1, 2) == 1) {
						$astre_x--;
					} else {
						$astre_x++;
					}
					//Coté vertical
					if (mt_rand(1, 2) == 1) {
						$astre_y--;
					} else {
						$astre_y++;
					}
					//Génération de la taille
					$astre_taille = mt_rand(_MAX_MOON_SIZE - 30, _MAX_MOON_SIZE + 30);
				} else {
					//Erreur
					$astre_x = 0;
					$astre_y = 0;
					$astre_taille = 0;
				}
				break;

			//Soleil
			case 3:
				//Génération de la position
				$astre_x = mt_rand(floor(_SECT_SIZE_X / 2) - 1, ceil(_SECT_SIZE_X / 2) + 1);
				$astre_y = mt_rand(floor(_SECT_SIZE_Y / 2) - 1, ceil(_SECT_SIZE_Y / 2) + 1);
				//Génération de la taille
				$astre_taille = _SUN_SIZE;
				break;

			//Asteroide
			case 4:
				//si positions asteroide précédent passées
				if (($astre_x >= 1 AND $astre_x <= _SECT_SIZE_X) AND
					($astre_y >= 1 AND $astre_x < _SECT_SIZE_X))
				{
					//Continuité horisontal
					$astre_x++;
					//Coté vertical
					if (mt_rand(1, 2) == 1) {
						$astre_y--;
					} else {
						$astre_y++;
					}
					//Génération de la taille
					$astre_taille = mt_rand(_MAX_ASTERO_SIZE - 10, _MAX_ASTERO_SIZE + 10);
				} else {
					//Erreur
					$this->addMapConsol("Erreur génération astress astero");
					$astre_x = 0;
					$astre_y = 0;
				}
				break;

			//Stations spatial
			case 5:
				//Génération de la position
				$astre_x = mt_rand(2, _SECT_SIZE_X - 2);
				$astre_y = mt_rand(2, _SECT_SIZE_Y - 2);
				//Génération de la taille
				$astre_taille = _STATION_SIZE;
				break;

			//Quasar
			case 6:
				//Génération de la position
				$astre_x = mt_rand(floor(_SECT_SIZE_X / 2) - 2, floor(_SECT_SIZE_X / 2) + 2);
				$astre_y = mt_rand(floor(_SECT_SIZE_Y / 2) - 2, floor(_SECT_SIZE_Y / 2) + 2);
				//Génération de la taille
				$astre_taille = _SPECIAL_SIZE;
				break;

			//Super nova
			case 7:
				//Génération de la position
				$astre_x = mt_rand(2, _SECT_SIZE_X - 2);
				$astre_y = mt_rand(2, _SECT_SIZE_Y - 2);
				//Génération de la taille
				$astre_taille = _SPECIAL_SIZE;
				break;

			//type inconue
			default:
				//Valeurs d'erreur
				$astre_x = 0;
				$astre_y = 0;
				$astre_taille = 0;
				break;
		}
	}

	/**
	 * calcule la probabilité de l'astre d'avoir ces valeurs
	 *
	 * @return int (valeur de probabilité)
	 **/
	 private function getAstrePosProbab(&$systeme, $astre_nom, $astre_x, $astre_y, $astre_type = 1) {

	 	$pobab_value = 50;
	 	$astre_distance = 0;

		//Si il y a déja des astres dans le systeme
	 	if (isset($systeme['astres']) AND count($systeme['astres']) > 0) {

			//Si astre en dehor des limites
			if (($astre_x <= 0 AND $astre_x >= _SECT_SIZE_X) AND
				($astre_y <= 0 AND $astre_y >= _SECT_SIZE_Y))
			{
				//aucune chance
				$pobab_value = 0;
				$this->addMapConsol("En dehors des limites systeme");

				return $pobab_value;
			}

			foreach($systeme['astres'] as &$astre) {
				//Si astre existe a cette position
				if ($astre_x == $astre['x'] AND $astre_y == $astre['y']) {
					//aucune chance
					$pobab_value = 0;

					$this->addMapConsol("Il y a deja un astre ici");
					break;
				}
			}
	 	}

		if ($pobab_value > 0) {

			//Si lune ou asteroide
			if ($astre_type == 2 OR $astre_type == 4) {
				//On shunte les traitements suivants
				return $pobab_value;
			}

			//parcoure des astres existants
			foreach($systeme['astres'] as &$astre) {

				if (($astre_x >= $astre['x'] - 2 AND $astre_x <= $astre['x'] + 2) AND
					($astre_y >= $astre['y'] - 2 AND $astre_y <= $astre['y'] + 2))
				{
					//peu de chance
					$pobab_value = 0;
					$this->addMapConsol("Trop collé a un astre");
					break;
				}
			}
		}

		return $pobab_value;
	 }

	 /**
	* Vérifie la neutralité du systeme
	* a partir d'une image blanche et bleu (bleu = zones neutres)
	*
	* @return int (systeme neutre ou pas, 1 ou 0)
	**/
	public function getSysNeutral($sys_x, $sys_y) {

		$neutral = 0;
		$color_id = NULL;
		//Calcule de la position en pixel
		$pos_x = ($sys_x * 15) - 6;
		$pos_y = ($sys_y * 15) - 6;

		if ($this->image_zones == NULL) {
			//Chargement de l'image de masque de forme
			$this->image_zones = imagecreatefromjpeg(_GAMEBASE . 'ressource/image/map/ress/map_zones_mask.jpg');
		}

		//Récupération de la couleur a la position
		$color_id = imagecolorat($this->image_zones, $pos_x, $pos_y);

		//Si dans zone bleu
		if ($color_id == 3368857) {
			$neutral = 1;
		}

		return $neutral;
	}

}
?>